// 版权归Go作者所有。版权所有。
// 此源代码的使用受BSD样式
// 许可证的约束，该许可证可以在许可证文件中找到。

package ssa

import (
	"cmd/compile/internal/ir"
	"cmd/compile/internal/types"
	"cmd/internal/src"
	"fmt"
	"math"
	"sort"
	"strings"
)

// 一个值表示程序的SSA表示中的一个值。
// 不能修改ID和类型字段。如果保留了值的值（例如，将a（mul 2 x）更改为an（add x x）），则可以修改剩余部分。
type Value struct {
	// 值的唯一标识符。为了提高性能，我们从1开始分配这些ID 
	// 。不过，不能保证不会偶尔出现漏洞。
	ID ID

	// 计算此值的操作。见op.go。
	Op Op

	// 此值的类型。通常这将是一个Go类型，但有
	// 还有一些其他的伪类型，请参阅/类型/类型。去
	Type *types.Type

	// 此值的辅助信息。此信息的类型取决于操作码和类型。
	// AuxInt用于整数值，Aux用于其他值。
	// 浮点数使用数学方法存储在生长素中。浮点64位（f）。
	// 生长素的未使用部分由扩展已使用部分的符号填充，
	// 即使表示的值是无符号的。
	// 将生长素解释为无信号（如轮班）的生长素使用者必须小心。
	// 使用值。AuxUnsigned得到生长素的零扩展值。
	AuxInt int64
	Aux    Aux

	// 此值的参数
	Args []*Value

	// 包含基本块
	Block *Block

	// 源位置
	Pos src.XPos

	// 使用计数。每一次出现的价值。Args和Block。控件计数一次。
	Uses int32

	// wasm:值保留在WebAssembly堆栈上。该值不会获得“寄存器”（WebAssembly变量）
	// 或Go堆栈上的插槽，并且该值的生成延迟到其使用时间。
	OnWasmStack bool

	// 此值是否在每函数常量缓存中？如果是这样，请在更改或回收缓存之前将其从缓存中删除。
	InCache bool

	// 前三个参数的存储
	argstorage [3]*Value
}

// 示例：
// 操作码辅助参数
// OpAdd nil 2 
// OpConst string 0 string constant 
// OpConst int64 0 int64 constant 
// OpAddcq int64 1 amd64 op:v=arg[0]+constant 

// 简式打印。就v#。
func (v *Value) String() string {
	if v == nil {
		return "nil" // 永远不应该发生，但不惊慌失措有助于调试
	}
	return fmt.Sprintf("v%d", v.ID)
}

func (v *Value) AuxInt8() int8 {
	if opcodeTable[v.Op].auxType != auxInt8 && opcodeTable[v.Op].auxType != auxNameOffsetInt8 {
		v.Fatalf("op %s doesn't have an int8 aux field", v.Op)
	}
	return int8(v.AuxInt)
}

func (v *Value) AuxInt16() int16 {
	if opcodeTable[v.Op].auxType != auxInt16 {
		v.Fatalf("op %s doesn't have an int16 aux field", v.Op)
	}
	return int16(v.AuxInt)
}

func (v *Value) AuxInt32() int32 {
	if opcodeTable[v.Op].auxType != auxInt32 {
		v.Fatalf("op %s doesn't have an int32 aux field", v.Op)
	}
	return int32(v.AuxInt)
}

// AuxUnsigned将v.AuxInt作为OpConst*的无符号值返回。
// v.AuxInt总是符号扩展到64位，即使
// 表示的值是无符号的。这将撤消符号扩展。
func (v *Value) AuxUnsigned() uint64 {
	c := v.AuxInt
	switch v.Op {
	case OpConst64:
		return uint64(c)
	case OpConst32:
		return uint64(uint32(c))
	case OpConst16:
		return uint64(uint16(c))
	case OpConst8:
		return uint64(uint8(c))
	}
	v.Fatalf("op %s isn't OpConst*", v.Op)
	return 0
}

func (v *Value) AuxFloat() float64 {
	if opcodeTable[v.Op].auxType != auxFloat32 && opcodeTable[v.Op].auxType != auxFloat64 {
		v.Fatalf("op %s doesn't have a float aux field", v.Op)
	}
	return math.Float64frombits(uint64(v.AuxInt))
}
func (v *Value) AuxValAndOff() ValAndOff {
	if opcodeTable[v.Op].auxType != auxSymValAndOff {
		v.Fatalf("op %s doesn't have a ValAndOff aux field", v.Op)
	}
	return ValAndOff(v.AuxInt)
}

func (v *Value) AuxArm64BitField() arm64BitField {
	if opcodeTable[v.Op].auxType != auxARM64BitField {
		v.Fatalf("op %s doesn't have a ValAndOff aux field", v.Op)
	}
	return arm64BitField(v.AuxInt)
}

// 长格式打印。v#=操作码<type>[aux]args[：reg]（名称）
func (v *Value) LongString() string {
	if v == nil {
		return "<NIL VALUE>"
	}
	s := fmt.Sprintf("v%d = %s", v.ID, v.Op)
	s += " <" + v.Type.String() + ">"
	s += v.auxString()
	for _, a := range v.Args {
		s += fmt.Sprintf(" %v", a)
	}
	var r []Location
	if v.Block != nil {
		r = v.Block.Func.RegAlloc
	}
	if int(v.ID) < len(r) && r[v.ID] != nil {
		s += " : " + r[v.ID].String()
	}
	var names []string
	if v.Block != nil {
		for name, values := range v.Block.Func.NamedValues {
			for _, value := range values {
				if value == v {
					names = append(names, name.String())
					break // 删除重复项。
				}
			}
		}
	}
	if len(names) != 0 {
		sort.Strings(names) // 否则会导致调试输出发生变化。
		s += " (" + strings.Join(names, ", ") + ")"
	}
	return s
}

func (v *Value) auxString() string {
	switch opcodeTable[v.Op].auxType {
	case auxBool:
		if v.AuxInt == 0 {
			return " [false]"
		} else {
			return " [true]"
		}
	case auxInt8:
		return fmt.Sprintf(" [%d]", v.AuxInt8())
	case auxInt16:
		return fmt.Sprintf(" [%d]", v.AuxInt16())
	case auxInt32:
		return fmt.Sprintf(" [%d]", v.AuxInt32())
	case auxInt64, auxInt128:
		return fmt.Sprintf(" [%d]", v.AuxInt)
	case auxARM64BitField:
		lsb := v.AuxArm64BitField().getARM64BFlsb()
		width := v.AuxArm64BitField().getARM64BFwidth()
		return fmt.Sprintf(" [lsb=%d,width=%d]", lsb, width)
	case auxFloat32, auxFloat64:
		return fmt.Sprintf(" [%g]", v.AuxFloat())
	case auxString:
		return fmt.Sprintf(" {%q}", v.Aux)
	case auxSym, auxCall, auxTyp:
		if v.Aux != nil {
			return fmt.Sprintf(" {%v}", v.Aux)
		}
	case auxSymOff, auxCallOff, auxTypSize, auxNameOffsetInt8:
		s := ""
		if v.Aux != nil {
			s = fmt.Sprintf(" {%v}", v.Aux)
		}
		if v.AuxInt != 0 || opcodeTable[v.Op].auxType == auxNameOffsetInt8 {
			s += fmt.Sprintf(" [%v]", v.AuxInt)
		}
		return s
	case auxSymValAndOff:
		s := ""
		if v.Aux != nil {
			s = fmt.Sprintf(" {%v}", v.Aux)
		}
		return s + fmt.Sprintf(" [%s]", v.AuxValAndOff())
	case auxCCop:
		return fmt.Sprintf(" {%s}", Op(v.AuxInt))
	case auxS390XCCMask, auxS390XRotateParams:
		return fmt.Sprintf(" {%v}", v.Aux)
	case auxFlagConstant:
		return fmt.Sprintf("[%s]", flagConstant(v.AuxInt))
	}
	return ""
}

// 如果启用midstack内联（-l=4），编译器会变大变慢。
// 不内联此方法有帮助（*Value.reset和*Block.NewValue0类似）。
// go:noinline 
func (v *Value) AddArg(w *Value) {
	if v.Args == nil {
		v.resetArgs() // 使用arg存储
	}
	v.Args = append(v.Args, w)
	w.Uses++
}

// go:noinline 
func (v *Value) AddArg2(w1, w2 *Value) {
	if v.Args == nil {
		v.resetArgs() // 使用arg存储
	}
	v.Args = append(v.Args, w1, w2)
	w1.Uses++
	w2.Uses++
}

// go:noinline 
func (v *Value) AddArg3(w1, w2, w3 *Value) {
	if v.Args == nil {
		v.resetArgs() // 使用arg存储
	}
	v.Args = append(v.Args, w1, w2, w3)
	w1.Uses++
	w2.Uses++
	w3.Uses++
}

// go:noinline 
func (v *Value) AddArg4(w1, w2, w3, w4 *Value) {
	v.Args = append(v.Args, w1, w2, w3, w4)
	w1.Uses++
	w2.Uses++
	w3.Uses++
	w4.Uses++
}

// go。
func (v *Value) AddArg5(w1, w2, w3, w4, w5 *Value) {
	v.Args = append(v.Args, w1, w2, w3, w4, w5)
	w1.Uses++
	w2.Uses++
	w3.Uses++
	w4.Uses++
	w5.Uses++
}

func (v *Value) AddArg6(w1, w2, w3, w4, w5, w6 *Value) {
	v.Args = append(v.Args, w1, w2, w3, w4, w5, w6)
	w1.Uses++
	w2.Uses++
	w3.Uses++
	w4.Uses++
	w5.Uses++
	w6.Uses++
}

func (v *Value) AddArgs(a ...*Value) {
	if v.Args == nil {
	}
	v.Args = append(v.Args, a...)
	for _, x := range a {
		x.Uses++
	}
}
func (v *Value) SetArg(i int, w *Value) {
	v.Args[i].Uses--
	v.Args[i] = w
	w.Uses++
}
func (v *Value) SetArgs1(a *Value) {
	v.resetArgs()
	v.AddArg(a)
}
func (v *Value) SetArgs2(a, b *Value) {
	v.resetArgs()
	v.AddArg(a)
	v.AddArg(b)
}
func (v *Value) SetArgs3(a, b, c *Value) {
	v.resetArgs()
	v.AddArg(a)
	v.AddArg(b)
	v.AddArg(c)
}

func (v *Value) resetArgs() {
	for _, a := range v.Args {
		a.Uses--
	}
	v.argstorage[0] = nil
	v.argstorage[1] = nil
	v.argstorage[2] = nil
	v.Args = v.argstorage[:0]
}

// 允许它内联会将cmd/compile的大小
// 增加近10%，并降低速度。
// go:noinline 
func (v *Value) reset(op Op) {
	if v.InCache {
		v.Block.Func.unCache(v)
	}
	v.Op = op
	v.resetArgs()
	v.AuxInt = 0
	v.Aux = nil
}

// Invalidater将一个值粗略地标记为无效（未使用）
// 并且在减少其参数上的引用计数后，
// 还递归地使任何使用
// 计数为零的值无效。它返回
// 无效值中是否有任何值被标记为IsStmt。
// 
// 在*您将预定的
// 更新应用到SSA之前，请小心这样做。
func (v *Value) invalidateRecursively() bool {
	lostStmt := v.Pos.IsStmt() == src.PosIsStmt
	if v.InCache {
		v.Block.Func.unCache(v)
	}
	v.Op = OpInvalid

	for _, a := range v.Args {
		a.Uses--
		if a.Uses == 0 {
			lost := a.invalidateRecursively()
			lostStmt = lost || lostStmt
		}
	}

	v.argstorage[0] = nil
	v.argstorage[1] = nil
	v.argstorage[2] = nil
	v.Args = v.argstorage[:0]

	v.AuxInt = 0
	v.Aux = nil
	return lostStmt
}

// 从重写规则调用copyOf。
// 它将v修改为be（复制a）。
// go:noinline 
func (v *Value) copyOf(a *Value) {
	if v == a {
		return
	}
	if v.InCache {
		v.Block.Func.unCache(v)
	}
	v.Op = OpCopy
	v.resetArgs()
	v.AddArg(a)
	v.AuxInt = 0
	v.Aux = nil
	v.Type = a.Type
}

// copyInto生成一个与v相同的新值，并将其添加到b的末尾。
// 与copyIntoWithXPos不同，这不检查v.Pos是否为语句。
func (v *Value) copyInto(b *Block) *Value {
	c := b.NewValue0(v.Pos.WithNotStmt(), v.Op, v.Type) // 失去位置，否则会导致行号波动。
	c.Aux = v.Aux
	c.AuxInt = v.AuxInt
	c.AddArgs(v.Args...)
	for _, a := range v.Args {
		if a.Type.IsMemory() {
			v.Fatalf("can't move a value with a memory arg %s", v.LongString())
		}
	}
	return c
}

// copyIntoWithXPos生成一个与v相同的新值，并将其添加到b的末尾。
// 提供的位置用作新值的位置。
// 因为这是用于重新材料化的，请检查（重新材料化的）
// 位置为“pos”的值的输入带有语句标记，并且提供的
// 位置（使用重物质化值的指令的位置）没有标记，如果其行与提供的位置匹配，则
// 保留该标记。
func (v *Value) copyIntoWithXPos(b *Block, pos src.XPos) *Value {
	if v.Pos.IsStmt() == src.PosIsStmt && pos.IsStmt() != src.PosIsStmt && v.Pos.SameFileAndLine(pos) {
		pos = pos.WithIsStmt()
	}
	c := b.NewValue0(pos, v.Op, v.Type)
	c.Aux = v.Aux
	c.AuxInt = v.AuxInt
	c.AddArgs(v.Args...)
	for _, a := range v.Args {
		if a.Type.IsMemory() {
			v.Fatalf("can't move a value with a memory arg %s", v.LongString())
		}
	}
	return c
}

func (v *Value) Logf(msg string, args ...interface{}) { v.Block.Logf(msg, args...) }
func (v *Value) Log() bool                            { return v.Block.Log() }
func (v *Value) Fatalf(msg string, args ...interface{}) {
	v.Block.Func.fe.Fatalf(v.Pos, msg, args...)
}

// isGenericIntConst报告v是否为通用整数常量。
func (v *Value) isGenericIntConst() bool {
	return v != nil && (v.Op == OpConst64 || v.Op == OpConst32 || v.Op == OpConst16 || v.Op == OpConst8)
}

// ResultReg返回分配给v的结果寄存器，格式为cmd/internal/obj/$ARCH编号。
// 它与Reg和Reg0类似，只是它可以互换用于所有值运算。
// 如果你知道v.Op，使用Reg或Reg0（视情况而定）会更有效率。
func (v *Value) ResultReg() int16 {
	reg := v.Block.Func.RegAlloc[v.ID]
	if reg == nil {
		v.Fatalf("nil reg for value: %s\n%s\n", v.LongString(), v.Block.Func)
	}
	if pair, ok := reg.(LocPair); ok {
		reg = pair[0]
	}
	if reg == nil {
		v.Fatalf("nil reg0 for value: %s\n%s\n", v.LongString(), v.Block.Func)
	}
	return reg.(*Register).objNum
}

// Reg以cmd/internal/obj/$ARCH编号返回分配给v的寄存器。
func (v *Value) Reg() int16 {
	reg := v.Block.Func.RegAlloc[v.ID]
	if reg == nil {
		v.Fatalf("nil register for value: %s\n%s\n", v.LongString(), v.Block.Func)
	}
	return reg.(*Register).objNum
}

// Reg0返回分配给v的第一个输出的寄存器，以cmd/internal/obj/$ARCH编号。
func (v *Value) Reg0() int16 {
	reg := v.Block.Func.RegAlloc[v.ID].(LocPair)[0]
	if reg == nil {
		v.Fatalf("nil first register for value: %s\n%s\n", v.LongString(), v.Block.Func)
	}
	return reg.(*Register).objNum
}

// Reg1返回分配给v的第二个输出的寄存器，以cmd/internal/obj/$ARCH编号。
func (v *Value) Reg1() int16 {
	reg := v.Block.Func.RegAlloc[v.ID].(LocPair)[1]
	if reg == nil {
		v.Fatalf("nil second register for value: %s\n%s\n", v.LongString(), v.Block.Func)
	}
	return reg.(*Register).objNum
}

func (v *Value) RegName() string {
	reg := v.Block.Func.RegAlloc[v.ID]
	if reg == nil {
		v.Fatalf("nil register for value: %s\n%s\n", v.LongString(), v.Block.Func)
	}
	return reg.(*Register).name
}

// MemoryArg返回值的内存参数。
// 如果返回的值不是nil，则将是内存类型的（或者是第二部分为内存类型的元组）。
// 否则返回nil。
func (v *Value) MemoryArg() *Value {
	if v.Op == OpPhi {
		v.Fatalf("MemoryArg on Phi")
	}
	na := len(v.Args)
	if na == 0 {
		return nil
	}
	if m := v.Args[na-1]; m.Type.IsMemory() {
		return m
	}
	return nil
}

// LackingPos表示v是否是一个不太可能有正确的
// 位置分配给它的值。忽略这些值会导致为附近的值和包含这些值的块分配更方便用户的位置
// 。
func (v *Value) LackingPos() bool {
	// LackingPos的确切定义是经过试探性定义的，将来可能会改变
	// 例如，如果这些操作中的一些是根据源位置更仔细地生成的
	// 的话。
	return v.Op == OpVarDef || v.Op == OpVarKill || v.Op == OpVarLive || v.Op == OpPhi ||
		(v.Op == OpFwdRef || v.Op == OpCopy) && v.Type == types.TypeMem
}

// removeable报告如果使用计数下降到0，是否可以从SSA图中完全删除值v。
func (v *Value) removeable() bool {
	if v.Type.IsVoid() {
		// 无效操作，就像零指针检查一样，必须保留。
		return false
	}
	if v.Type.IsMemory() {
		// 我们不需要保留所有内存操作，但至少需要
		// 来保留调用（因为它们可能有我们看不到的同步操作）。
		return false
	}
	if v.Op.HasSideEffects() {
		// 这些主要是同步操作。
		return false
	}
	return true
}

// TODO（mdempsky）：应该没有必要；参见golang的讨论。org/cl/275756 
func (*Value) CanBeAnSSAAux() {}

// AutoVar返回一个*名称和int64，表示自动变量及其内部的偏移量
// v应溢出的位置。
func AutoVar(v *Value) (*ir.Name, int64) {
	if loc, ok := v.Block.Func.RegAlloc[v.ID].(LocalSlot); ok {
		if v.Type.Size() > loc.Type.Size() {
			v.Fatalf("spill/restore type %s doesn't fit in slot type %s", v.Type, loc.Type)
		}
		return loc.N, loc.Off
	}
	// 假设它是一个寄存器，返回它的溢出槽，它需要是活动的
	nameOff := v.Aux.(*AuxNameOffset)
	return nameOff.Name, nameOff.Offset
}
